import User from '../models/User.js';
import dotenv from 'dotenv';
import CaptchaService from '../services/captchaService.js';
import SM2Service from '../services/sm2Service.js';
import JWTService from '../services/jwtService.js';
dotenv.config();

class AuthController {
  // 用户登录
  static async login(req, res) {
    try {
      const { username, password, captchaId, captchaText, encryptedPassword } = req.body;
      
      // 1. 验证验证码
      if (!captchaId || !captchaText) {
        return res.status(400).json({
          success: false,
          message: '请提供验证码'
        });
      }
      
      const isCaptchaValid = CaptchaService.verifyCaptcha(captchaId, captchaText);
      if (!isCaptchaValid) {
        return res.status(400).json({
          success: false,
          message: '验证码错误或已过期'
        });
      }
      
      // 2. 验证用户名
      if (!username) {
        return res.status(400).json({
          success: false,
          message: '请提供用户名'
        });
      }
      
      // 3. 查找用户
      const user = await User.findByUsername(username);
      if (!user) {
        return res.status(401).json({
          success: false,
          message: '用户名或密码错误'
        });
      }
      
      // 4. 处理密码验证（支持明文和加密密码）
      let isPasswordValid = false;
      if (encryptedPassword) {
        // 使用SM2私钥解密密码
        try {
          // 注意：这里为了演示，使用临时生成的私钥
          // 实际生产环境应该从安全的密钥管理系统获取
          const keyPair = SM2Service.generateKeyPair();
          const decryptedPassword = SM2Service.decrypt(encryptedPassword, keyPair.privateKey);
          isPasswordValid = await user.validatePassword(decryptedPassword);
        } catch (decryptError) {
          console.error('密码解密失败:', decryptError);
          return res.status(401).json({
            success: false,
            message: '用户名或密码错误'
          });
        }
      } else if (password) {
        // 直接验证明文密码（开发环境使用）
        isPasswordValid = await user.validatePassword(password);
      } else {
        return res.status(400).json({
          success: false,
          message: '请提供密码'
        });
      }
      
      if (!isPasswordValid) {
        return res.status(401).json({
          success: false,
          message: '用户名或密码错误'
        });
      }
      
      // 5. 生成JWT令牌
      let accessToken = JWTService.generateAccessToken(user.id, user.username);
      
      // 6. 增强令牌，添加设备和IP信息
      accessToken = JWTService.enhanceAccessTokenWithRequestInfo(accessToken, req);
      
      // 7. 生成刷新令牌
      const refreshToken = JWTService.generateRefreshToken(user.id, user.username);
      
      // 8. 返回成功响应
      return res.json({
        success: true,
        message: '登录成功',
        tokens: {
          accessToken,
          refreshToken
        },
        user: user.toJSON()
      });
    } catch (error) {
      console.error('登录错误:', error);
      return res.status(500).json({
        success: false,
        message: '服务器错误'
      });
    }
  }
  
  // 生成验证码
  static async generateCaptcha(req, res) {
    try {
      const captcha = CaptchaService.generateCaptcha();
      
      return res.json({
        success: true,
        captchaId: captcha.captchaId,
        svg: captcha.svg
      });
    } catch (error) {
      console.error('生成验证码错误:', error);
      return res.status(500).json({
        success: false,
        message: '生成验证码失败'
      });
    }
  }
  
  // 刷新令牌
  static async refreshToken(req, res) {
    try {
      const { refreshToken } = req.body;
      
      if (!refreshToken) {
        return res.status(400).json({
          success: false,
          message: '请提供刷新令牌'
        });
      }
      
      // 验证刷新令牌
      const result = JWTService.verifyRefreshToken(refreshToken);
      if (!result.isValid) {
        return res.status(401).json({
          success: false,
          message: result.error
        });
      }
      
      // 查找用户
      const user = await User.findByUsername(result.decoded.username);
      if (!user) {
        return res.status(401).json({
          success: false,
          message: '用户不存在'
        });
      }
      
      // 生成新的访问令牌
      let newAccessToken = JWTService.generateAccessToken(user.id, user.username);
      newAccessToken = JWTService.enhanceAccessTokenWithRequestInfo(newAccessToken, req);
      
      return res.json({
        success: true,
        tokens: {
          accessToken: newAccessToken,
          refreshToken // 保持原刷新令牌
        }
      });
    } catch (error) {
      console.error('刷新令牌错误:', error);
      return res.status(500).json({
        success: false,
        message: '服务器错误'
      });
    }
  }
  
  // 获取SM2公钥
  static async getPublicKey(req, res) {
    try {
      // 注意：这里为了演示，每次请求生成新的密钥对
      // 实际生产环境应该使用固定的公钥，或者从密钥管理系统获取
      const keyPair = SM2Service.generateKeyPair();
      
      return res.json({
        success: true,
        publicKey: keyPair.publicKey
      });
    } catch (error) {
      console.error('生成公钥错误:', error);
      return res.status(500).json({
        success: false,
        message: '生成公钥失败'
      });
    }
  }

  // 用户注册
  static async register(req, res) {
    try {
      const { username, password } = req.body;
      
      // 验证输入
      if (!username || !password) {
        return res.status(400).json({
          success: false,
          message: '请提供用户名和密码'
        });
      }
      
      if (password.length < 6) {
        return res.status(400).json({
          success: false,
          message: '密码长度至少为6位'
        });
      }
      
      // 创建用户
      const user = await User.create(username, password);
      
      return res.status(201).json({
        success: true,
        message: '注册成功',
        user: user.toJSON()
      });
    } catch (error) {
      if (error.message === '用户已存在') {
        return res.status(400).json({
          success: false,
          message: error.message
        });
      }
      console.error('注册错误:', error);
      return res.status(500).json({
        success: false,
        message: '服务器错误'
      });
    }
  }

  // 获取当前用户信息
  static async getCurrentUser(req, res) {
    try {
      // 从JWT中获取用户信息
      const user = req.user;
      if (!user) {
        return res.status(401).json({
          success: false,
          message: '未授权'
        });
      }
      
      return res.json({
        success: true,
        user: user.toJSON()
      });
    } catch (error) {
      console.error('获取用户信息错误:', error);
      return res.status(500).json({
        success: false,
        message: '服务器错误'
      });
    }
  }
}

export default AuthController;